שיעור מספר 7: מקושרים

Transcription

1 שיעור מספר 7: מקושרים אוהד ברזילי דן הלפרין בית הספר למדעי המחשב

2 על סדר היום נתחיל בדוגמא נאיבית של מבנה מקושר נכליל את המבנה ע"י הכללת טיפוסים נדון בייצוג הכרות אינטימית בשפת התכנות נדון בהפשטת מעבר סידרתי על נתונים והשלכותיו 2

3 מבנים מקושרים כדי לייצג מבנים מקושרים, כגון רשימה מקושרת, עץ, וכדומה, מגדירים מחלקות שכוללות שדות שמתייחסים לעצמים נוספים מאותה מחלקה )ולפעמים גם למחלקות נוספות (. כדוגמא פשוטה ביותר, נגדיר מחלקה IntCell שעצמים בה מייצגים אברים ברשימות מקושרות של שלמים. המחלקה מייצאת בנאי ליצירת עצם כאשר התוכן )שלם( והאבר הבא הם פרמטרים. המחלקה מייצאת שאילתות עבור התוכן והאבר הבא, ופקודות לשינוי האבר הבא, ולהדפסת תוכן הרשימה מהאבר הנוכחי השדות מוגדרים כפרטיים מוסתרים מהלקוחות המבנה IntCell אנלוגי למבנה cons משפת :Scheme car אנלוגי ל cont() cdr אנלוגי ל next() 3

4 class IntCell public class IntCell { private int cont; private IntCell next; public IntCell(int cont, IntCell next) { this.cont = cont; this.next = next; public int cont() { return cont; 4

5 class IntCell public IntCell next() { return next; public void setnext(intcell next) { this.next = next; public void printlist() { System.out.print("List: "); משתנה העזר של הלולאה הוא מטיפוס IntCell for (IntCell y = this; y!= null; y = y.next()) System.out.print(y.cont() + " "); System.out.println(); 5

6 מחלקה לביצוע בדיקות כדי לבדוק שהמחלקה שכתבנו פועלת כנדרש, נכתוב מחלקה התחלתית לבדיקה, שתכיל שרות הראשי.main בהמשך הקורס נעסוק בנושא בדיקות (testing) אך כרגע נציין שעלינו לבחור מקרי בדיקה שמכסים אפשרויות שונות כדי שנוכל לגלות שגיאות )אם יש( חשוב! שגיאות של מחלקה או שרות מוגדרות בהקשר של החוזה של המחלקה. אם למחלקה )או לשרות שלה( אין חוזה מפורש לא ברור מהי ההתנהגות ה"נכונה" במקרי קצה בהרצאה היום נסתפק באינטואיציה שיש לנו לגבי רשימות מקושרות 6

7 מחלקה לביצוע בדיקות public class Test { public static void main(string[] args) { IntCell x = null; IntCell y = new IntCell(5,x); y.printlist(); IntCell z = new IntCell(3,y); z.printlist(); z.setnext(new IntCell(2,y)); z.printlist(); y.printlist(); 7

8 מחלקה לביצוע בדיקות הפלט List: 5 List: 3 5 List: List: 5 איך ניצור מבנה מקושר של תווים? או של מחרוזות? יצירת מחלקה חדשה כגון StringCell או CharCell תשכפל הרבה מהלוגיקה הקיימת ב IntCell יש צורך בהפשטת הטיפוס int מטיפוס הנתונים Cell היינו רוצים להכליל את הטיפוס Cell לעבוד עם כל סוגי הטיפוסים 8

9 מחלקות ושרותים מוכללים )גנריים( החל מגירסא 1.5 )נקראת גם ) 5.0 ג'אווה מאפשרת הגדרת מחלקות גנריות ושרותים גנריים )Generics( מחלקה גנרית מגדירה טיפוס גנרי, שמציין אחד או יותר משתני טיפוס variables) (type בתוך סוגריים משולשים. עקב ההוספה המאוחרת לשפה )והדרישה שקוד שנכתב קודם יוכל לעבוד ביחד עם קוד חדש(, ומשיקולים של יעילות המימוש, כללי השפה לגבי טיפוסים גנריים הם מורכבים. 9

10 מחלקות ושרותים מוכללים )גנריים( רעיון דומה קיים גם בשפת התכנות ++C ב ++C נקראת תכונה זו תבנית )template( כרגע נציג רק את המקרה הפשוט. לדון בנושא ביתר פירוט. בהמשך נחזור דוגמא ראשונה הכללה של המחלקה IntCell לייצוג תא שתוכנו מטיפוס פרמטרי T, כך שכל התאים ברשימה הם מאותו הטיפוס. 10

11 Cell <T> public class Cell <T> { private T cont; private Cell <T> next; public Cell (T cont, Cell <T> next) { this.cont = cont; this.next = next; 11

12 Cell <T> public T cont() { return cont; public Cell <T> next() { return next; public void setnext(cell <T> next) { this.next = next; 12

13 Cell <T> public void printlist() { System.out.print("List: "); for (Cell <T> y = this; y!= null; y = y.next()) System.out.print(y.cont() + " "); System.out.println(); 13

14 מה השתנה במחלקה? לכותרת המחלקה נוסף משתנה הטיפוס T מקובל ששמות משתני טיפוס הם אות גדולה אחת אולם זו אינה דרישה תחבירית, ניתן לקרוא למשתנה הטיפוס בשם משמעותי הטיפוס שמוגדר הוא <T> Cell הטיפוס של כל שדה, פרמטר, משתנה זמני, של שרות שהיה int יוחלף ב T וכל טיפוס מוחזר הטיפוס של כל שדה, פרמטר, משתנה זמני, של שרות שהיה Cell יוחלף ב Cell<T> וכל טיפוס מוחזר 14

15 שימוש בטיפוס גנרי כדי להשתמש בטיפוס גנרי יש לספק, בהצהרה על משתנה, ובקריאה לבנאי, טיפוס קונקרטי עבור כל משתנה טיפוס שלו. לדוגמא: Cell <Integer> באנלוגיה להגדרת שרות וקריאה לו, משתנה טיפוס בהגדרת המחלקה מהווה מעין פרמטר פורמלי, והטיפוס הקונקרטי הוא מעין פרמטר אקטואלי. 15

16 דוגמת שימוש בטיפוס גנרי נראה מחלקה שמשתמשת ב <T> Cell שהשתמשה ב : IntCell, שהיא אנלוגית למחלקה public class TestGen { public static void main(string[] args) { Cell <Integer> x = null; Cell <Integer> y = new Cell<Integer>(5,x); y.printlist(); Cell<Integer> z = new Cell <Integer>(3,y); z.printlist(); z.setnext(new Cell <Integer>(2,y)); z.printlist(); y.printlist(); 16

17 שימוש בטיפוס גנרי הטיפוס הקונקרטי חייב להיות טיפוס הפנייה, אינו יכול להיות פרימיטיבי. כלומר אם רוצים ליצור למשל תאים שתוכנם הוא מספר שלם, לא ניתן לכתוב <int> Cell לצורך זה נזדקק לטיפוסים עוטפים (wrapper type) 17

18 טיפוסים עוטפים (wrappers) לכל טיפוס פרימיטיבי קיים בג'אווה טיפוס הפנייה מתאים: ל- float העוטף, Float ל- double העוטף Double וכו' int המתאים ל, Integer ו- char יוצאי דופן: Character המתאים ל- כל הטיפוסים העוטפים מקובעים )immutable( הטיפוסים העוטפים שימושיים כאשר יש צורך בעצם ביצירת אוספים של ערכים, ובשימוש בטיפוס גנרי( )למשל 18

19 Boxing and Unboxing ניתן לתרגם טיפוס פרימיטיבי לטיפוס העוטף שלו )boxing( ע"י קריאה לבנאי המתאים: char pc = 'c'; Character rc = new Character(pc); ניתן לתרגם טיפוס עוטף לטיפוס הפרימיטיבי המתאים )unboxing( ע"י שימוש במתודות xxxvalue המתאימות: Float rf = new Float(3.0); float pf = rf.floatvalue(); בין טיפוס פרימיטיבי לטיפוס העוטף שלו: Integer i = 0;// autoboxing int n = i; // autounboxing if(n==i) // true i++; // i==1 System.out.println(i+n); // 3 ג'אווה 1.5 מאפשרת מעבר אוטומטי 19

20 עוד על שימוש בטיפוס גנרי ניתן להגדיר משתנה )שדה, משתנה זמני, פרמטר( מהטיפוס <Integer>> Cell <Cell גם מה מייצג הטיפוס הזה? דוגמא של הצהרה עם אתחול: Cell <Cell <Integer> > q = new Cell <Cell <Integer>> (new Cell<Integer> (8,null), null); 20

21 ? מי אתה Cell<T> האם Cell<T> באמת מייצג רשימה מקושרת? בשפת Scheme התשובה היא כן. אולם ב Java אמצעים טובים יותר להפשטת טיפוסים יש בשפה Cell אינו רשימה הוא תא ניתן )וצריך!( לבטא את שני הרעיונות רשימה ותא כטיפוסים בשפה עם תכונות המתאימות לרמת ההפשטה שלהן נציג את המחלקה MyList<T> המייצגת רשימה 21

22 קרוב ראשון ל- MyList<T> public class MyList <T> { private Cell <T> head; public MyList (Cell <T> head) { this.head = head; המחלקה נקראת MyList ולא List כדי שלא נתבלבל בינה ובין java.util.list מהספרייה הסטנדרטית של Java public Cell<T> gethead() { return head; public void printlist() { System.out.print("List: "); for (Cell <T> y = head; y!= null; y = y.next()) System.out.print(y.cont() + " "); System.out.println(); 22

23 חסרונות המימוש מימוש הרשימה אמור להיות חלק מהייצוג הפנימי שלה ומוסתר מהלקוח במימוש המוצע לקוחות המחלקה MyList צריכים להכיר גם את המחלקה Cell Cell <Integer> x = null; Cell <Integer> y = new Cell<Integer>(5,x); Cell <Integer> z = new Cell<Integer>(3,y); MyList<Integer> l = new MyList<Integer>(z); l.printlist(); להחליף את המימוש לרשימה הדבר פוגע בהפשטת רשימה מקושרת למשל, אם בעתיד ירצה ספק MyCell דו-כיוונית 23

24 - קרוב שני MyList<T> public class MyList<T> { private Cell <T> head; private Cell <T> curr; public MyList (T... elements) { this.head = null; for (int i = elements.length-1; i >= 0; i--) { head = new Cell<T>(elements[i], head); curr = head; public boolean atend(){ return curr == null; */ public void advance() { curr = curr.next(); 24

25 - המשך MyList<T> */ public T cont() { return curr.cont(); השרות אינו מחזיר את התא הנוכחי )טיפוס )Cell אלא את התוכן של התא הנוכחי )T( */ public void addnext(t elem) { Cell<T> temp = new Cell<T>(elem, curr.next()); curr.setnext(temp); public void printlist() { System.out.print("List: "); for (Cell <T> y = head; y!= null; y = y.next()) System.out.print(y.cont() + " "); System.out.println(); ידפיס את תוצאת הפעלת השרות y.cont() על T של הטיפוס tostring 25

26 MyList<T> כעת לקוח הרשימה )MyList( :Cell<T> אינו מודע לקיום מחלקת העזר MyList<Integer> l = new MyList<Integer>(3,5); l.printlist(); l.advance(); l.addnext(4); l.printlist(); 26

27 ע) MyList<T> איך נממש את השרות (x addhere(int את האיבר x למקום הנוכחי ברשימה: שרות המוסיף בשונה מהשרות addnext() אנו צריכים לשנות את ההצבעה לתא.curr לשם כך ניתן לנקוט כמה גישות: גישה א': תחזוקה של prev נוסף על curr גישה ב': נרוץ מתחילת הרשימה עד המקום אחד לפני הנוכחי "י השוואת next() של כל תא ל )curr גישה ג': החלפת תכני התאים head 3 4 curr head curr 4 27

28 יחסים אינטימיים גישות א' ו- ב' פשוטות יותר רעיונית אך פחות אלגנטיות )תחזוקה, ביצועים( ננסה לממש את גישה ג */ public void addhere(t elem) { Cell<T> temp = new Cell<T>(elem, curr.next()); curr.setnext(temp); temp.cont = curr.cont(); curr.cont = elem; אולי במקרה זה דרישת הפרטיות של נראות של השדה cont היא מוגזמת? הקלת הנראות של שדה אינה מוצדקת ואולם, המחלקה Cell<T> היא מחלקת עזר של <T> MyList ולכן יש הצדקה למתן הרשאות גישה חריגות ל- <T> MyList לשדותיה הפרטיים של Cell<T> גם לו היתה ל Cell המתודה setcont() ניתן היה לאמר כי לאור השימוש התכוף שעושה הרשימה בשרותי התא, ניתן היה משיקולי יעילות לאפשר לה גישה ישירה לשדה זה 28

29 יחסים אינטימיים ב Java אם Cell ו MyList באותה חבילה אפשר להשתמש בנראות חבילה - אבל אז כל מחלקה אחרת בחבילה תוכל גם היא לגשת לפריטים האלה של Cell ניתן להגדיר אינטימיות בין מחלקות ב Java כמחלקה פנימית של המחלקה האחרת ע"י הגדרת אחת המחלקות מחלקות פנימיות הן מבנה תחבירי בשפת Java המבטא בין השאר הכרות אינטימית הערה על דרגות נראות: דרגת הנראות ב Java היא ברמת המחלקה. כלומר עצם מטיפוס כלשהו יכול לגשת גם לשדות הפרטיים של עצם אחר מאותו הטיפוס ניתן היה לחשוב גם על נראות ברמת העצם )לא קיים ב )Java 29

30 Inner Classes מחלקה פנימית היא מחלקה שהוגדרה בתחום Scope( בין המסולסליים( של מחלקה אחרת public class House { private String address; public class Room { private double width; private double height; 30 דוגמא: שימוש לב! Room אינה שדה של המחלקה House אם רוצים ליצור שדה כזה יש לעשות זאת במפורש

31 מחלקות פנימיות הגדרת מחלקה כפנימית מרמזת על היחס בין המחלקה הפנימית והמחלקה העוטפת: למחלקה הפנימית יש משמעות רק בהקשר של המחלקה החיצונית למחלקה הפנימית יש הכרות אינטימית עם המחלקה החיצונית המחלקה הפנימית היא מחלקת עזר של המחלקה החיצונית Cell ו- List דוגמאות: Iterator ו- Collection Brain ו- Body מבני נתונים המוגדרים ברקורסיה: 31

32 סוגי מחלקות פנימיות ב Java כל מופע של עצם מטיפוס המחלקה הפנימית משויך לעצם מטיפוס המחלקה העוטפת השלכות תחביר מיוחד לבנאי לעצם מטיפוס המחלקה הפנימית יש שדה הפנייה שמיוצר אוטומטית לעצם מהמחלקה העוטפת כתוצאה לכך יש למחלה הפנימית גישה לשדות ולשרותים )אפילו פרטיים!( של המחלקה העוטפת ולהיפך ניתן להגדיר מחלקה פנימית כ static ובכך לציין שהיא אינה קשורה למופע מסוים של המחלקה העוטפת הדבר אנלוגי למחלקה שכל שרותיה הוגדרו כ static והיא משמשת כספריה עבור מחלקה מסוימת בשפת ++C יחס זה מושג ע"י הגדרת יחס friend ניתן להגדיר מחלקה פנימית בתוך מתודה של המחלקה החיצונית ניתן להגדיר מחלקה פנימית אנונימית - הדבר שימושי במיוחד בספריות בהמשך הקורס.GUI פרטים 32

33 חזרה ל MyList ו Cell כדי להסתיר מהלקוח של הרשימה את הייצוג הפנימי, וכדי לאפשר גישה לשדות הפרטיים של נכתוב את Cell כמחלקה מקוננת, פרטית בתוך MyList האם מחלקה פנימית סטטית או לא? אפשרות אחת: Cell אינה סטטית אז כל עצם מסוג Cell משויך לעצם MyList כלומר לרשימה מסוימת, ומאפשר לעצם להכיר את הרשימה בה הוא מופיע. אבל מה נעשה אם הוא יעבור לרשימה אחרת? למעשה זה בלתי אפשרי! האבר )התוכן( יכול להיות מוכנס לרשימה אחרת, אבל לא העצם מטיפוס Cell אפשרות שנייה: Cell סטטית מה ההשלכות מבחינת הגנריות? 33

34 רשימה עם מחלקה מקוננת אם Cell מחלקה מקוננת לא סטטית בתוך MyList היא לא חייבת להיות מוגדרת כגנרית. טיפוס התוכן של ה Cell נקבע על פי הפרמטר האקטואלי של עצם ה MyList המתאים. כלומר הרשימה קובעת את סוג אבריה, עבור רשימה מסוימת שותפים לאותו וכל האברים שנוצרים קצת יותר קל לכתוב את הקוד הערה: נראות השדות והשרותים של מחלקה מקוננת פרטית אינה משמעותית )בכל מקרה ידועים למחלקה העוטפת ורק לה(. 34

35 public class MyList<T> { private class Cell { private T cont; private Cell next; { public T cont() { return cont; public Cell next() { return next; //... private Cell head; private Cell curr; public MyList(...) {... public boolean atend() { return curr == null; */ public void advance() { curr = curr.next(); //... 35

36 רשימה עם מחלקה מקוננת סטטית אם Cell סטטית היא חייבת להיות גנרית, כי אחרת, עבור: private T cont; נקבל הודעת שגיאה: Cannot make a static reference to the non-static type T כי אם Cell סטטית, היא לא מתייחסת לעצם מטיפוס,MyList שטיפוס האבר שלו נקבע ביצירתו, אלא למחלקה <T> MyList שבה לא נקבע טיפוס קונקרטי ל T אם כן, מה הפרמטר הגנרי שלה? T או אחר? שתי האפשרויות הן חוקיות, אבל צריך להבין שבכל מקרה אלה שני משתנים שונים, והשימוש עלול להיות מבלבל 36

37 public class MyList<T> { private static class Cell<S> { private S cont; private Cell<S> next; public Cell(S cont, Cell<S> next) { this.cont = cont; this.next = next; public S cont() { return cont; public Cell next() { return next; //... private Cell<T> head; private Cell<T> curr; public MyList(/*... */)... public boolean atend() { return curr == null; */ public void advance() { curr = curr.next(); //... 37

38 דיון: printlist() printlist() היא שרות גרוע בעיה: השרות פונה למסך זוהי החלטה שיש לשמור "לזמן קונפיגורציה". אולי הלקוח מעוניין להדפיס את המידע למקור אחר פתרון: שימוש ב tostring שרות זה יחזיר את אברי הרשימה כמחרוזת והלקוח יעשה במחרוזת כרצונו בעיה: השרות מכתיב את פורמט הדפסה )כותרות, רווחים, שורות חדשות( ומגביל את הלקוח לפורמט זה. הלקוח לא יכול לאסוף מידע זה בעצמו שכן הוא אפילו לא מכיר את המחלקה Cell 38

39 Iterator Design Pattern נפתור בעיה זו ע"י שימוש בתבנית התיכון עיצוב( Iterator )תבנית Iterator אינו חלק משפת התכנות אלא הוא מייצג קונספט, רעיון, קלישאה תכנותית שמאפשרת לייצג את רעיון סריקת מבנה נתונים כללי בשפות תכנות מוכוונות עצמים )#C,++C( Java, ממומשים איטרטורים שימושיים כטיפוס בספריה הסטנדרטית 39

40 איטרטור )סודר? אצן? סורק?( איטרטור הוא הפשטה של מעבר כלשהו כדי לבצע פעולה ישירה על מבנה נתונים, כיצד הוא מיוצג על מבנה נתונים יש לדעת גישה בעזרת איטרטור למבנה הנתונים מאפשרת למשתמש לסרוק מבנה נתונים ללא צורך להכיר את המבנה הפנימי שלו נדגים זאת על שני מבני נתונים המחזיקים תווים 40

41 הדפסת מערך )אינדקסים( char[] letters = {'a','b','c','d','e','f'; void printletters() { System.out.print("Letters: "); for (int i=0 ; i < letters.length ; i++) { System.out.print(letters[i] + " "); System.out.println(); 41

42 הדפסת רשימה מקושרת public class MyList<T> {... public void printlist() { System.out.print("Letters : "); for (Cell<T> y = head; y!= null ; y = y.getnext()) { System.out.print(y.getCont() + " "); System.out.println(); a b c d e f 42

43 הכרות אינטימית עם מבנה הנתונים 2 הדוגמאות הקודמות חושפות ידע מוקדם שיש לכותבת פונקצית ההדפסה על מבנה הנתונים: היא יודעת איפה הוא מתחיל ואיפה הוא נגמר היא מכירה את מבנה הטיפוס שבעזרתו ניתן לקבל את המידע השמור במצביע היא יודעת איך לעבור מאיבר לאיבר שאחריו בדוגמת הרשימה המקושרת כותבת המחלקה MyList היא זו שכתבה את מתודת ההדפסה )הספקית( זה אינו מצב רצוי - זהו רק מקרה פרטי של פעולה אחת מני רבות שלקוחות עשויים לרצות לבצע על מחלקה. על המחלקה לספק כלים ללקוחותיה לבצע פעולות כאלו בעצמם 43

44 האיטרטור איטרטור הוא בעצם מנשק )interface( המגדיר פעולות יסודיות שבעזרתן ניתן לבצע מגוון רחב של פעולות על אוספים ב Java טיפוס יקרא Iterator אם ניתן לבצע עליו 4 פעולות: בדיקה האם גלשנו )hasnext()( קידום )next()( גישה לנתון עצמו )next()( הסרה של נתון )remove()( 44

45 האיטרטור כן, זה נורא! next() היא גם פקודה וגם שאילתה ממש כשם שמימושים מסוימים של pop() על מחסנית גם מסירים את האיבר העליון וגם מחזירים אותו בשפות אחרות c++( או :)Eiffel יש הפרדה בין קידום משתנה העזר והגישה לנתון remove() אינה חלק משרותי איטרטור )וכך גם אנו סבורים( 45

46 אלגוריתם כללי להדפסת אוסף נתונים נדפיס את האיברים השמורים במבנה נתונים collection כלשהו: for (Iterator iter = collection.iterator(); iter.hasnext( ); ) { System.out.println(iter.next()); מבנה הנתונים עצמו אחראי לספק ללקוח איטרטור תיקני ממחלקה שמממשת את ממשק )Iterator המאותחל לתחילת מבנה הנתונים )עצם אם נרצה שהמחלקה MyList תספק ללקוחותיה את האפשרות לסרוק את כל האיברים ברשימה, עלינו לכתוב לה Iterator 46

47 MyListIterator תקני class MyListIterator<S> implements Iterator<S> { public MyListIterator(Cell<S> cell) { this.curr = cell; public boolean hasnext() { return curr!= null; public S next() { S result = curr.getcont(); curr = curr.getnext(); return result; public void remove() { // must be implemented private Cell<S> curr; 47

48 MyList<T> מספקת איטרטור ללקוחותיה public class MyList<T> implements Iterable<T> { //... public Iterator<T> iterator() { return new MyListIterator<T>(head); מחלקות המממשות את המתודה iterator() בעצם מממשות את המנשק Iterable<T> המכיל מתודה זו בלבד הצימוד בין MyList ו- MyListIterator חזק. על כן מקובל לממש את האיטרטור כמחלקה פנימית של האוסף שעליו הוא פועל כעת הלקוח יכול לבצע פעולות על כל אברי הרשימה בלי לדעת מהו המבנה הפנימי שלה 48

49 printsquares public void printsquares( Iterable<Integer> MyList<Integer> list ds ) { for (Iterator<Integer> iter = list.iterator(); ds iter.hasnext();) { int i = iter.next(); Autoboxing System.out.println(i*i); What is the output for: System.out.println(iter.next()*iter.next()); )שמרו לכן על הפרדה בין פקודות לשאיתות( הלקוח מדפיס את ריבועי אברי הרשימה בלי להשתמש בעובדה שזו אכן רשימה טיפוס הארגומנט MyList<Integer> יכול להיות מוחלף בשם המנשק < Iterable<Integer,ואז הלקוח לא ידע אפילו את שמו של טיפוס מבנה הנתונים 49

50 for/in (foreach) לולאת for שמבצעת את אותה פעולה על כל אברי אוסף נתונים כלשהו כה שכיחה, עד שב Java 5.0 הוסיפו אותה לשפה בתחביר מיוחד )for/in( הקוד מהשקף הקודם שקול לקוד הבא: public void printsquares(mylist<integer> list) { for (int i : list) System.out.println(i*i); יש לקרוא זאת כך: "לכל איבר i מטיפוס int שבאוסף הנתונים "...list אוסף הנתונים list חייב לממש את המנשק Iterable 50

51 for/in (foreach) ראינו כי מערכים מתנהגים כטיפוס :Iterable int[] arr = {6,5,4,3,2,1; for (int i : arr) { System.out.println(i*i); שימוש נכון במבנה for/in מייתר רבים משימושי האיטרטור 51